package com.ruoyi.common.utils.digital;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 通用浮点数精度处理工具类
 */
public class FloatPreProcessor {

    /**
     * 处理对象中所有 float/Float 字段，使用指定精度
     * @param obj 需要处理的对象
     * @param precision 要应用的小数位数
     */
    public static void processFloatPrecision(Object obj, int precision) {
        if (obj == null) {
            return;
        }

        processAllFloatFieldsRecursive(obj, obj.getClass(), precision);
    }

    /**
     * 递归处理对象及其父类中的所有 float/Float 字段
     * @param obj 对象实例
     * @param clazz 对象的类
     * @param precision 精度
     */
    private static void processAllFloatFieldsRecursive(Object obj, Class<?> clazz, int precision) {
        if (clazz == null || clazz == Object.class) {
            return;
        }

        // 处理当前类的字段
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            try {
                // 处理所有 float 或 Float 类型的字段
                if (field.getType() == float.class || field.getType() == Float.class) {
                    field.setAccessible(true);

                    // 获取字段值并处理精度
                    Object processedValue = null;
                    Object originalValue = field.get(obj);

                    // 处理 Float 对象类型
                    if (originalValue instanceof Float) {
                        processedValue = processFloatValue((Float) originalValue, precision);
                    }
                    // 处理 float 基本类型
                    else if (field.getType() == float.class) {
                        float floatValue = field.getFloat(obj);
                        processedValue = processFloatValue(floatValue, precision);
                    }

                    // 如果值发生了变化，则设置回对象
                    if (processedValue != null && !processedValue.equals(originalValue)) {
                        field.set(obj, processedValue);
                    }
                }
            } catch (Exception e) {
                // 记录异常但不中断处理流程
            }
        }

        // 递归处理父类
        processAllFloatFieldsRecursive(obj, clazz.getSuperclass(), precision);
    }

    /**
     * 处理 Float 对象的精度
     * @param value Float 值
     * @param precision 精度
     * @return 处理后的值
     */
    private static Float processFloatValue(Float value, int precision) {
        // 只有当值有效时才进行精度处理
        if (value != null && !value.isNaN() && !value.isInfinite()) {
            try {
                BigDecimal bd = new BigDecimal(value.toString());
                return bd.setScale(precision, RoundingMode.HALF_UP).floatValue();
            } catch (NumberFormatException e) {
                // 如果转换失败，返回原值
                return value;
            }
        }
        // 值无效时直接返回原值
        return value;
    }

    /**
     * 处理 float 基本类型的精度
     * @param value float 值
     * @param precision 精度
     * @return 处理后的值
     */
    private static float processFloatValue(float value, int precision) {
        // 只有当值有效时才进行精度处理
        if (!Float.isNaN(value) && !Float.isInfinite(value)) {
            try {
                BigDecimal bd = new BigDecimal(Float.toString(value));
                return bd.setScale(precision, RoundingMode.HALF_UP).floatValue();
            } catch (NumberFormatException e) {
                // 如果转换失败，返回原值
                return value;
            }
        }
        // 值无效时直接返回原值
        return value;
    }
}
